{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 查看FashionMNIST数据集的原始内容"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<PIL.Image.Image image mode=L size=28x28 at 0x1FE850614F0>, 9)\n"
     ]
    },
    {
     "data": {
      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/wAALCAAcABwBAREA/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/9oACAEBAAA/APn+tbw1oNx4m8QWmkWx2yXD4LkZCADJJ+gFbviL4a63oc7COE3MW4hdn38duD976jNc9daDqllIsc9lKrMu4YGeMkdR7gj8KzcV7H8BtEvV16+1iWCeG1Wz8mOV02pIzupwCeuAp6Z98cZ90aIzLIlw0c0ZJ4KgjHoeOa+evjS9n/wnMcNxBPCYLKONFhA2FNzMpGenDcgd816V4K03wefC+m3NlpVhP+5QSXBiR5fMx825iMg5zwce3FdbOzTwgW90lu6uCm8eYrL02soIyCPQgggEdMGQ3cluiPNK0rJwrRQBNueuMkt+teNfGKxsdY8WWdxNqcNo66eieXMwVsb5DnH415Hp2rajpE5n02/urOUjBe3laMkehIPIrVm8eeLrhNknibVivoLtx/I1UPinxC3XXtUP1vJP8ay5JZJpGkldnduSzHJP41//2Q==",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACS0lEQVR4AWKgA2BkYOD1ZGBgZAHZxcjIAKZBbBBm+quS8v3rj1N/GBiZGP8wMKNIMv91cnnCzuU65+X/vww8/76hSP5iMFVgZtpp2HXm8nUz02PHGUHGQTHjf9cugd//GE7f+cUo8ft0yDSEJCMDw/8TCgyMf34x/Ph3/vYfT0VphLH/GRgY3kt+Z2fl+cH5z8aSSWwHqmsZuJiZvn18p/CPkYnr7z9ZBiaofQwMjMwMPFI/frH++sr/j537K9sldhOE5H9mhnBJJg4Gbtlf7L//cQhvusaCkGT5xXDlBxsXl6rSD2Yunr9PoraeYAGZx8T4+x/DHwaGbV+/s/1/zczxm+H3P2a9jwxMDMz///z6+Y+BwW7ime9v//z78/XrXw6GbwxsX4NAYc3AICSlJhmk/oPpN+czVjbhX1zHeOz+fWR9qcnIYNkkKvCX+cMfrl+M36+HneEVVGC4x/v5GycPHxcj83GpP3+/MTB/Z2DgF0lwy3z24/49VeFfrLxsf+UBY0xqv8vDw87Ayv/4mSiTRACHIrexMdMvJjYGRlYLlpeP+X485mHje/eQ5/uPP+svKwj9+vD77y/Wf4xsaixP/z/mFvnw5jULOysHL9Mbza+P37O/+f3nN6fERwOWC+sTn937wcPGwcb88+//by/+/WX5wfPrw4fffxRfMjIweBWLv/7wl5mNhZnxPysrGysjA+NLBrZ/EpfCGJn+MTA4tYnxMzGz/GV8+f/pvy/MDP9/f2Paff0YJBAYGBg0RN/LPPx1Fx5HFDIAaCTYdiCc4RIAAAAASUVORK5CYII=",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=28x28>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看FashionMNIST数据集的格式\n",
    "\n",
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from torchvision import datasets,transforms\n",
    "from deeplearning_train import EarlyStopping,ModelSaver,train_classification_model,plot_learning_curves\n",
    "from deeplearning_train import evaluate_classification_model as evaluate_model\n",
    "\n",
    "\n",
    "# 定义数据转换\n",
    "transform = transforms.Compose([]) # 创建一个空的转换组合，不对数据进行任何预处理或转换操作\n",
    "                                   # 这里使用transforms.Compose([])表示不对图像进行任何变换，保持原始格式\n",
    "                                   # 在后续代码中会加载原始格式的FashionMNIST数据，用于查看其原始数据格式\n",
    "\n",
    "# 加载FashionMNIST训练集\n",
    "train_dataset = torchvision.datasets.FashionMNIST(\n",
    "    root='./data',  # 数据存储路径\n",
    "    train=True,  # 指定为训练集\n",
    "    download=True,  # 如果数据不存在则下载\n",
    "    transform=transform  # 应用数据转换\n",
    ")\n",
    "\n",
    "# 加载FashionMNIST测试集\n",
    "test_dataset = torchvision.datasets.FashionMNIST(\n",
    "    root='./data',  # 数据存储路径\n",
    "    train=False,  # 指定为测试集\n",
    "    download=True,  # 如果数据不存在则下载\n",
    "    transform=transform  # 应用数据转换\n",
    ")\n",
    "\n",
    "\n",
    "# 打印训练集的第一个样本\n",
    "print(train_dataset[0])\n",
    "# 打印训练集的第一个样本的图像\n",
    "train_dataset[0][0]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 加载数据集，处理为tensor格式，查看其形状"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集图像形状: (60000, 28, 28)\n",
      "训练集标签形状: (60000,)\n",
      "测试集图像形状: (10000, 28, 28)\n",
      "测试集标签形状: (10000,)\n"
     ]
    }
   ],
   "source": [
    "# 定义新的数据转换，将图像转换为张量格式\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),  # 将PIL图像转换为PyTorch张量，并将像素值归一化到[0,1]范围\n",
    "    transforms.Normalize((0.286,), (0.353,))  # 将像素值归一化到[-1,1]范围\n",
    "])\n",
    "\n",
    "# 重新加载FashionMNIST训练集，应用张量转换\n",
    "train_dataset = datasets.FashionMNIST(\n",
    "    root='./data',  # 数据存储路径\n",
    "    train=True,     # 指定为训练集\n",
    "    download=True,  # 如果数据不存在则下载\n",
    "    transform=transform  # 应用张量转换\n",
    ")\n",
    "\n",
    "# 重新加载FashionMNIST测试集，应用张量转换\n",
    "test_dataset = datasets.FashionMNIST(\n",
    "    root='./data',  # 数据存储路径\n",
    "    train=False,    # 指定为测试集\n",
    "    download=True,  # 如果数据不存在则下载\n",
    "    transform=transform  # 应用张量转换\n",
    ")\n",
    "\n",
    "# 获取图像和标签\n",
    "train_images = train_dataset.data.numpy()\n",
    "train_labels = train_dataset.targets.numpy()\n",
    "test_images = test_dataset.data.numpy()\n",
    "test_labels = test_dataset.targets.numpy()\n",
    "\n",
    "# 定义类别名称\n",
    "class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',\n",
    "               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
    "               \n",
    "\n",
    "# 打印数据集的基本信息\n",
    "print(f\"训练集图像形状: {train_images.shape}\")  # 打印训练集图像的形状\n",
    "print(f\"训练集标签形状: {train_labels.shape}\")  # 打印训练集标签的形状\n",
    "print(f\"测试集图像形状: {test_images.shape}\")   # 打印测试集图像的形状\n",
    "print(f\"测试集标签形状: {test_labels.shape}\")   # 打印测试集标签的形状\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 把数据集划分为训练集55000，验证集5000，测试集10000，并给DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集大小: 55000\n",
      "验证集大小: 5000\n",
      "测试集大小: 10000\n",
      "批次大小: 64\n",
      "训练批次数: 860\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 从训练集中划分出验证集\n",
    "train_size = 55000  # 定义训练集的大小为55000个样本\n",
    "val_size = 5000  # 定义验证集的大小为5000个样本\n",
    "# 设置随机种子以确保每次得到相同的随机划分结果\n",
    "generator = torch.Generator().manual_seed(42)  # 创建一个随机数生成器并设置种子为42\n",
    "train_subset, val_subset = torch.utils.data.random_split(\n",
    "    train_dataset,  # 要分割的原始训练数据集，60000个样本\n",
    "    [train_size, val_size],  # 分割的大小列表，55000个训练样本和5000个验证样本\n",
    "    generator=generator  # 使用之前创建的随机数生成器，确保每次得到相同的随机划分结果\n",
    ")\n",
    "\n",
    "# DataLoader是PyTorch中用于批量加载数据的工具，能够高效地将数据集分割成小批次，并支持数据打乱、并行加载等功能，\n",
    "# 极大地提升了模型训练和测试时的数据处理效率。\n",
    "batch_size = 64  # 设置批次大小为64\n",
    "train_loader = torch.utils.data.DataLoader(   \n",
    "    train_subset,  # 使用训练子集创建数据加载器\n",
    "    batch_size=batch_size,  # 设置批次大小\n",
    "    shuffle=True  # 打乱数据集，每次迭代时，数据集的顺序都会被打乱\n",
    ")\n",
    "\n",
    "val_loader = torch.utils.data.DataLoader(\n",
    "    val_subset,  # 使用验证子集创建数据加载器\n",
    "    batch_size=batch_size,  # 设置批次大小\n",
    "    shuffle=False  # 不打乱验证集数据顺序\n",
    ")\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    test_dataset,  # 使用测试集创建数据加载器，10000个样本\n",
    "    batch_size=batch_size,  # 设置批次大小\n",
    "    shuffle=False  # 不打乱测试集数据顺序\n",
    ")\n",
    "\n",
    "# 打印数据集大小信息\n",
    "print(f\"训练集大小: {len(train_subset)}\")  # 打印训练集的样本数量\n",
    "print(f\"验证集大小: {len(val_subset)}\")  # 打印验证集的样本数量\n",
    "print(f\"测试集大小: {len(test_dataset)}\")  # 打印测试集的样本数量\n",
    "print(f\"批次大小: {batch_size}\")  # 打印每个批次的大小\n",
    "print(f\"训练批次数: {len(train_loader)}\")  # 打印训练过程中的批次总数\n",
    "\n",
    "# DataLoader的作用和优势解释\n",
    "\n",
    "# DataLoader是PyTorch中用于加载数据的工具，它提供了以下几个关键功能：\n",
    "\n",
    "# 1. 批次处理（Batching）\n",
    "#    - 将数据集分割成大小相等的批次（batch）  # 批次处理使模型训练更高效\n",
    "#    - 每次迭代返回一个批次的数据，而不是单个样本  # 批量处理数据可以加速训练过程\n",
    "\n",
    "# 2. 数据打乱（Shuffling）\n",
    "#    - 通过shuffle=True参数启用  # 设置是否在每个epoch打乱数据\n",
    "#    - 有助于模型泛化，防止模型记住数据顺序  # 打乱数据可以提高模型的泛化能力\n",
    "\n",
    "# 3. 并行加载（Parallel loading）\n",
    "#    - 通过num_workers参数控制  # 设置数据加载的工作进程数\n",
    "#    - 使用多个CPU核心同时加载数据，提高效率  # 并行加载可以减少数据准备时间\n",
    "\n",
    "# 4. 内存优化\n",
    "#    - 只在需要时加载数据，而不是一次性加载整个数据集  # 按需加载数据减少内存占用\n",
    "#    - 适合处理大型数据集  # 对于大数据集尤其有用\n",
    "\n",
    "# 5. 预处理集成\n",
    "#    - 可以通过Dataset的__getitem__方法或DataLoader的collate_fn参数  # 提供数据预处理的方式\n",
    "#    - 在加载数据时自动应用变换和预处理  # 实现数据加载和预处理的无缝集成\n",
    "\n",
    "# 在我们的代码中：\n",
    "# - train_loader: 用于训练，启用了数据打乱以提高模型泛化能力  # 训练加载器配置了数据打乱\n",
    "# - val_loader和test_loader: 用于评估，不打乱数据以确保结果一致性  # 评估加载器保持数据顺序\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55040"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "64*860"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([20, 100])\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import torch  # 导入PyTorch库\n",
    "m=nn.BatchNorm1d(100)  # 创建一个一维批归一化层，归一化特征维度为100\n",
    "# 这行代码创建了一个BatchNorm1d对象，用于对一维特征进行批量归一化\n",
    "# 参数100表示要归一化的特征数量，即输入张量的特征维度\n",
    "# BatchNorm1d通过计算每个特征维度上的均值和方差，对每个mini-batch的数据进行归一化处理\n",
    "# 这有助于加速训练过程、提高模型稳定性，并允许使用更高的学习率\n",
    "x=torch.randn(20,100)  # 创建一个随机张量，形状为[20,100]，表示20个样本，每个样本100个特征\n",
    "print(m(x).shape)  # 将张量通过批归一化层处理，并打印输出张量的形状\n",
    "\n",
    "# 批归一化(BatchNorm1d)的作用:\n",
    "# 1. 加速网络训练 - 通过归一化每一层的输入，使梯度更稳定\n",
    "# 2. 允许使用更高的学习率 - 减少了内部协变量偏移问题\n",
    "# 3. 减少对初始化的依赖 - 使网络对权重初始化不那么敏感\n",
    "# 4. 具有轻微的正则化效果 - 添加了微小的噪声，有助于泛化\n",
    "# 5. 在每个小批次上独立进行归一化操作，使每个特征维度的分布更稳定"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 搭建CNN模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义MNIST分类CNN模型\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "class CNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        # 第一组卷积层 - 输入1通道，输出32通道\n",
    "        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)  # 第一个卷积层，1通道输入，32通道输出，3x3卷积核，1个填充\n",
    "        self.conv2 = nn.Conv2d(32, 32, kernel_size=3, padding=1)  # 第二个卷积层，32通道输入，32通道输出，3x3卷积核，1个填充\n",
    "        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)  # 第一个最大池化层，2x2窗口，步长2\n",
    "        \n",
    "        # 第二组卷积层 - 输入32通道，输出64通道\n",
    "        self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)  # 第三个卷积层，32通道输入，64通道输出，3x3卷积核\n",
    "        self.conv4 = nn.Conv2d(64, 64, kernel_size=3, padding=1)  # 第四个卷积层，64通道输入，64通道输出，3x3卷积核\n",
    "        \n",
    "        \n",
    "        # 第三组卷积层 - 输入64通道，输出128通道\n",
    "        self.conv5 = nn.Conv2d(64, 128, kernel_size=3, padding=1)  # 第五个卷积层，64通道输入，128通道输出，3x3卷积核\n",
    "        self.conv6 = nn.Conv2d(128, 128, kernel_size=3, padding=1)  # 第六个卷积层，128通道输入，128通道输出，3x3卷积核\n",
    "        \n",
    "        \n",
    "        # 全连接层，输入128*3*3，输出512\n",
    "        self.fc1 = nn.Linear(128 * 3 * 3, 256)  # 第一个全连接层，输入维度为128*3*3=1152，输出维度为256\n",
    "        # 这行代码创建了一个全连接层，连接卷积层输出和最终分类层\n",
    "        # 输入维度128*3*3来自最后一个池化层输出的特征图尺寸(3x3)与通道数(128)的乘积\n",
    "        # 输出维度256是一个中间特征表示，用于进一步降维到最终的10个类别\n",
    "        self.fc2 = nn.Linear(256, 10)  # 第二个全连接层，输入256，输出10（对应10个数字类别）\n",
    "        \n",
    "        self.init_weights() # 初始化权重\n",
    "\n",
    "    def init_weights(self):\n",
    "            \"\"\"使用 xavier 均匀分布来初始化卷积层和全连接层的权重\"\"\"\n",
    "            for m in self.modules():  # 遍历模型中的所有模块\n",
    "                if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):  # 判断模块是否为卷积层或全连接层\n",
    "                    nn.init.xavier_uniform_(m.weight)  # 使用xavier均匀分布初始化权重，有助于解决深度网络的梯度消失/爆炸问题\n",
    "                    if m.bias is not None:  # 检查偏置是否存在\n",
    "                        nn.init.zeros_(m.bias)  # 将偏置初始化为零\n",
    "\n",
    "    def forward(self, x):\n",
    "        # 第一组卷积层\n",
    "        x = F.relu(self.conv1(x))  # 应用第一个卷积层并使用ReLU激活函数\n",
    "        # print(f\"conv1 output shape: {x.shape}\")  # 打印第一个卷积层输出的形状\n",
    "        x = F.relu(self.conv2(x))  # 应用第二个卷积层并使用ReLU激活函数\n",
    "        # print(f\"conv2 output shape: {x.shape}\")  # 打印第二个卷积层输出的形状\n",
    "        x = self.pool(x)  # 应用第一个池化层\n",
    "        # print(f\"pool1 output shape: {x.shape}\")  # 打印第一个池化层输出的形状\n",
    "        \n",
    "        # 第二组卷积层\n",
    "        x = F.relu(self.conv3(x))  # 应用第三个卷积层并使用ReLU激活函数\n",
    "        # print(f\"conv3 output shape: {x.shape}\")  # 打印第三个卷积层输出的形状\n",
    "        x = F.relu(self.conv4(x))  # 应用第四个卷积层并使用ReLU激活函数\n",
    "        # print(f\"conv4 output shape: {x.shape}\")  # 打印第四个卷积层输出的形状\n",
    "        x = self.pool(x)  # 应用第二个池化层\n",
    "        # print(f\"pool2 output shape: {x.shape}\")  # 打印第二个池化层输出的形状\n",
    "        \n",
    "        # 第三组卷积层\n",
    "        x = F.relu(self.conv5(x))  # 应用第五个卷积层并使用ReLU激活函数\n",
    "        # print(f\"conv5 output shape: {x.shape}\")  # 打印第五个卷积层输出的形状\n",
    "        x = F.relu(self.conv6(x))  # 应用第六个卷积层并使用ReLU激活函数\n",
    "        # print(f\"conv6 output shape: {x.shape}\")  # 打印第六个卷积层输出的形状\n",
    "        x = self.pool(x)  # 应用第三个池化层\n",
    "        # print(f\"pool3 output shape: {x.shape}\")  # 打印第三个池化层输出的形状\n",
    "        \n",
    "        # 展平特征图，准备输入全连接层\n",
    "        x = x.view(x.size(0), -1)  # 将特征图展平为一维向量，x.size(0)保留批次大小，-1自动计算剩余维度，将三维特征图(通道,高,宽)转换为二维张量(批次,特征)，以便输入全连接层\n",
    "        # print(f\"flatten output shape: {x.shape}\")  # 打印展平后的形状\n",
    "        \n",
    "        # 全连接层\n",
    "        x = F.relu(self.fc1(x))  # 应用第一个全连接层并使用ReLU激活函数\n",
    "        # print(f\"fc1 output shape: {x.shape}\")  # 打印第一个全连接层输出的形状\n",
    "        x = self.fc2(x)  # 应用第二个全连接层（输出层）\n",
    "        # print(f\"fc2 output shape: {x.shape}\")  # 打印第二个全连接层输出的形状\n",
    "        \n",
    "        return x\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "批次图像形状: torch.Size([64, 1, 28, 28])\n",
      "批次标签形状: torch.Size([64])\n",
      "----------------------------------------------------------------------------------------------------\n",
      "torch.Size([64, 10])\n"
     ]
    }
   ],
   "source": [
    "model = CNN()\n",
    "\n",
    "# 从train_loader获取第一个批次的数据\n",
    "dataiter = iter(train_loader)  # 将训练数据加载器转换为迭代器对象\n",
    "images, labels = next(dataiter)  # 从迭代器中获取下一个批次的图像和标签数据\n",
    "\n",
    "# 查看批次数据的形状\n",
    "print(\"批次图像形状:\", images.shape)  # 打印图像批次的维度信息，通常为[batch_size, channels, height, width]\n",
    "print(\"批次标签形状:\", labels.shape)  # 打印标签批次的维度信息，通常为[batch_size]\n",
    "\n",
    "\n",
    "print('-'*100)  # 打印100个连字符作为分隔线，提高输出可读性\n",
    "# 进行前向传播\n",
    "with torch.no_grad():  # 不需要计算梯度，减少内存使用并加快计算速度\n",
    "    outputs = model(images)  # 将图像输入模型，获取模型的预测输出\n",
    "print(outputs.shape)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "各层参数量明细:\n",
      "conv1.weight: 288 参数\n",
      "conv1.bias: 32 参数\n",
      "conv2.weight: 9216 参数\n",
      "conv2.bias: 32 参数\n",
      "conv3.weight: 18432 参数\n",
      "conv3.bias: 64 参数\n",
      "conv4.weight: 36864 参数\n",
      "conv4.bias: 64 参数\n",
      "conv5.weight: 73728 参数\n",
      "conv5.bias: 128 参数\n",
      "conv6.weight: 147456 参数\n",
      "conv6.bias: 128 参数\n",
      "fc1.weight: 294912 参数\n",
      "fc1.bias: 256 参数\n",
      "fc2.weight: 2560 参数\n",
      "fc2.bias: 10 参数\n",
      "模型总参数量: 584170\n",
      "需要训练的参数量: 584170\n"
     ]
    }
   ],
   "source": [
    "# 计算模型的总参数量\n",
    "total_params = sum(p.numel() for p in model.parameters())  # 计算模型中所有参数的数量\n",
    "trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)  # 计算需要求梯度的参数数量\n",
    "# 查看每层参数量明细\n",
    "print(\"\\n各层参数量明细:\")\n",
    "for name, param in model.named_parameters():\n",
    "    print(f\"{name}: {param.numel()} 参数\")\n",
    "print(f\"模型总参数量: {total_params}\")  # 打印模型的总参数量\n",
    "print(f\"需要训练的参数量: {trainable_params}\")  # 打印需要训练的参数量\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "288"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "32*3*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cpu\n",
      "训练开始，共训练43000步\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b6170cd30db24250a35e6e4ecd6e2532",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/43000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "早停触发! 最佳验证准确率: 92.3400\n",
      "早停: 已有5轮验证损失没有改善！\n"
     ]
    }
   ],
   "source": [
    "# 定义损失函数和优化器\n",
    "from torch import optim\n",
    "criterion = nn.CrossEntropyLoss()  # 定义交叉熵损失函数，适用于多分类问题\n",
    "optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)  # 定义随机梯度下降优化器，学习率为0.01，动量为0.9\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "model = model.to(device)\n",
    "\n",
    "early_stopping = EarlyStopping(patience=5, delta=0.001)\n",
    "model_saver = ModelSaver(save_dir='model_weights', save_best_only=True)\n",
    "\n",
    "\n",
    "model, history = train_classification_model(model, train_loader, val_loader, criterion, optimizer, device, num_epochs=50, early_stopping=early_stopping, model_saver=model_saver, tensorboard_logger=None)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_learning_curves(history,sample_step=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(91.44, 0.3275110371351242)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_accuracy=evaluate_model(model,test_loader,device,criterion)\n",
    "test_accuracy"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
